package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;
import java.util.List;
import java.util.Arrays;
import br.com.telescope.t2.ApplicationInfo;
import br.com.telescope.t2.EntityBean;
import br.com.telescope.util.JdbcUtil;

/**
 * API de persistência de dados da entidade SEQUENCES
 * @author Gerado pelo Telescope
 */
public class EntSequences extends Entity {
    
    public final static String ENTITY_NAME = "SEQUENCE.SEQUENCES";
    public final static String TABLE_NAME = "SEQUENCES";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntSequences() {
        super();
        initialize();
    }
    
    public EntSequences(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aSequence = new DomUpper(this,"SEQUENCE", "Sequence"); 
        aSequence.setRequired(true);
        oSequence = new DomUpper();
        aNextValue = new DomBigInteger(this,"NEXT_VALUE", "Next value"); 
        aNextValue.setRequired(true);
        aNextValue.setDefaultValue("1");
        oNextValue = new DomBigInteger();
        aCache = new DomInteger(this,"CACHE", "Cache"); 
        aCache.setRequired(true);
        aCache.setDefaultValue("1");
        oCache = new DomInteger();
        aDescription = new DomTextLong(this,"DESCRIPTION", "Description"); 
        oDescription = new DomTextLong();
        aMaxValue = new DomBigInteger(this,"MAX_VALUE", "Max value"); 
        oMaxValue = new DomBigInteger();
        aNextRangeMinValue = new DomBigInteger(this,"NEXT_RANGE_MIN_VALUE", "Next range min value"); 
        oNextRangeMinValue = new DomBigInteger();
        aNextRangeMaxValue = new DomBigInteger(this,"NEXT_RANGE_MAX_VALUE", "Next range max value"); 
        oNextRangeMaxValue = new DomBigInteger();
        aRangeSize = new DomInteger(this,"RANGE_SIZE", "Range size"); 
        oRangeSize = new DomInteger();
        aAttributes = new DomTextLong(this,"ATTRIBUTES", "Attributes"); 
        oAttributes = new DomTextLong();
        aRandom = new DomFlag(this,"RANDOM", "Random"); 
        aRandom.setRequired(true);
        aRandom.setSize(1);
        aRandom.setDefaultValue("N");
        oRandom = new DomFlag();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Sequence
    private DomUpper aSequence;
    private DomUpper oSequence;
    
    // Next value
    private DomBigInteger aNextValue;
    private DomBigInteger oNextValue;
    
    // Cache
    private DomInteger aCache;
    private DomInteger oCache;
    
    // Description
    private DomTextLong aDescription;
    private DomTextLong oDescription;
    
    // Max value
    private DomBigInteger aMaxValue;
    private DomBigInteger oMaxValue;
    
    // Next range min value
    private DomBigInteger aNextRangeMinValue;
    private DomBigInteger oNextRangeMinValue;
    
    // Next range max value
    private DomBigInteger aNextRangeMaxValue;
    private DomBigInteger oNextRangeMaxValue;
    
    // Range size
    private DomInteger aRangeSize;
    private DomInteger oRangeSize;
    
    // Attributes
    private DomTextLong aAttributes;
    private DomTextLong oAttributes;
    
    // Random
    private DomFlag aRandom;
    private DomFlag oRandom;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntSequences id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo SEQUENCE">
    
    public EntSequences sequence(String value) {
        setSequence(value);
        return this;
    }
    
    public void setSequence(DomUpper value) {
        if (value == null || value.isNull()) {
            nullifySequence();
        } else {
            aSequence.setValue(value.getValue());
            if (aSequence.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSequence(String value) {
        if (value == null) {
            nullifySequence();
        } else {
            aSequence.setValue(value);
            if (aSequence.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSequence(Object value) {
        aSequence.setValue(value);
        if (aSequence.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifySequence() {
        if (!aSequence.isNull()) {
            aSequence.setNull(true);
            setModified(true);
        }
    }
    
    public DomUpper getSequence() {
        return aSequence;
    }
    
    public DomUpper oldSequence() {
        return oSequence;
    }
    
    public String valueOfSequence() {
        return aSequence.getValue();
    }
    
    public boolean isSequenceModified() {
        return aSequence.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo NEXT_VALUE">
    
    public EntSequences nextValue(Long value) {
        setNextValue(value);
        return this;
    }
    
    public void setNextValue(DomBigInteger value) {
        if (value == null || value.isNull()) {
            nullifyNextValue();
        } else {
            aNextValue.setValue(value.getValue());
            if (aNextValue.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNextValue(String value) {
        if (value == null) {
            nullifyNextValue();
        } else {
            aNextValue.setValue(value);
            if (aNextValue.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNextValue(Long value) {
        aNextValue.setValue(value);
        if (aNextValue.isModified()) {
            setModified(true);
        }
    }
    
    public void setNextValue(Object value) {
        aNextValue.setValue(value);
        if (aNextValue.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyNextValue() {
        if (!aNextValue.isNull()) {
            aNextValue.setNull(true);
            setModified(true);
        }
    }
    
    public DomBigInteger getNextValue() {
        return aNextValue;
    }
    
    public DomBigInteger oldNextValue() {
        return oNextValue;
    }
    
    public Long valueOfNextValue() {
        return aNextValue.getValue();
    }
    
    public boolean isNextValueModified() {
        return aNextValue.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo CACHE">
    
    public EntSequences cache(Integer value) {
        setCache(value);
        return this;
    }
    
    public void setCache(DomInteger value) {
        if (value == null || value.isNull()) {
            nullifyCache();
        } else {
            aCache.setValue(value.getValue());
            if (aCache.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCache(String value) {
        if (value == null) {
            nullifyCache();
        } else {
            aCache.setValue(value);
            if (aCache.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCache(Integer value) {
        aCache.setValue(value);
        if (aCache.isModified()) {
            setModified(true);
        }
    }
    
    public void setCache(Object value) {
        aCache.setValue(value);
        if (aCache.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyCache() {
        if (!aCache.isNull()) {
            aCache.setNull(true);
            setModified(true);
        }
    }
    
    public DomInteger getCache() {
        return aCache;
    }
    
    public DomInteger oldCache() {
        return oCache;
    }
    
    public Integer valueOfCache() {
        return aCache.getValue();
    }
    
    public boolean isCacheModified() {
        return aCache.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo DESCRIPTION">
    
    public EntSequences description(String value) {
        setDescription(value);
        return this;
    }
    
    public void setDescription(DomTextLong value) {
        if (value == null || value.isNull()) {
            nullifyDescription();
        } else {
            aDescription.setValue(value.getValue());
            if (aDescription.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDescription(String value) {
        if (value == null) {
            nullifyDescription();
        } else {
            aDescription.setValue(value);
            if (aDescription.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setDescription(Object value) {
        aDescription.setValue(value);
        if (aDescription.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyDescription() {
        if (!aDescription.isNull()) {
            aDescription.setNull(true);
            setModified(true);
        }
    }
    
    public DomTextLong getDescription() {
        return aDescription;
    }
    
    public DomTextLong oldDescription() {
        return oDescription;
    }
    
    public String valueOfDescription() {
        return aDescription.getValue();
    }
    
    public boolean isDescriptionModified() {
        return aDescription.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo MAX_VALUE">
    
    public EntSequences maxValue(Long value) {
        setMaxValue(value);
        return this;
    }
    
    public void setMaxValue(DomBigInteger value) {
        if (value == null || value.isNull()) {
            nullifyMaxValue();
        } else {
            aMaxValue.setValue(value.getValue());
            if (aMaxValue.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setMaxValue(String value) {
        if (value == null) {
            nullifyMaxValue();
        } else {
            aMaxValue.setValue(value);
            if (aMaxValue.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setMaxValue(Long value) {
        aMaxValue.setValue(value);
        if (aMaxValue.isModified()) {
            setModified(true);
        }
    }
    
    public void setMaxValue(Object value) {
        aMaxValue.setValue(value);
        if (aMaxValue.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyMaxValue() {
        if (!aMaxValue.isNull()) {
            aMaxValue.setNull(true);
            setModified(true);
        }
    }
    
    public DomBigInteger getMaxValue() {
        return aMaxValue;
    }
    
    public DomBigInteger oldMaxValue() {
        return oMaxValue;
    }
    
    public Long valueOfMaxValue() {
        return aMaxValue.getValue();
    }
    
    public boolean isMaxValueModified() {
        return aMaxValue.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo NEXT_RANGE_MIN_VALUE">
    
    public EntSequences nextRangeMinValue(Long value) {
        setNextRangeMinValue(value);
        return this;
    }
    
    public void setNextRangeMinValue(DomBigInteger value) {
        if (value == null || value.isNull()) {
            nullifyNextRangeMinValue();
        } else {
            aNextRangeMinValue.setValue(value.getValue());
            if (aNextRangeMinValue.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNextRangeMinValue(String value) {
        if (value == null) {
            nullifyNextRangeMinValue();
        } else {
            aNextRangeMinValue.setValue(value);
            if (aNextRangeMinValue.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNextRangeMinValue(Long value) {
        aNextRangeMinValue.setValue(value);
        if (aNextRangeMinValue.isModified()) {
            setModified(true);
        }
    }
    
    public void setNextRangeMinValue(Object value) {
        aNextRangeMinValue.setValue(value);
        if (aNextRangeMinValue.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyNextRangeMinValue() {
        if (!aNextRangeMinValue.isNull()) {
            aNextRangeMinValue.setNull(true);
            setModified(true);
        }
    }
    
    public DomBigInteger getNextRangeMinValue() {
        return aNextRangeMinValue;
    }
    
    public DomBigInteger oldNextRangeMinValue() {
        return oNextRangeMinValue;
    }
    
    public Long valueOfNextRangeMinValue() {
        return aNextRangeMinValue.getValue();
    }
    
    public boolean isNextRangeMinValueModified() {
        return aNextRangeMinValue.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo NEXT_RANGE_MAX_VALUE">
    
    public EntSequences nextRangeMaxValue(Long value) {
        setNextRangeMaxValue(value);
        return this;
    }
    
    public void setNextRangeMaxValue(DomBigInteger value) {
        if (value == null || value.isNull()) {
            nullifyNextRangeMaxValue();
        } else {
            aNextRangeMaxValue.setValue(value.getValue());
            if (aNextRangeMaxValue.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNextRangeMaxValue(String value) {
        if (value == null) {
            nullifyNextRangeMaxValue();
        } else {
            aNextRangeMaxValue.setValue(value);
            if (aNextRangeMaxValue.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNextRangeMaxValue(Long value) {
        aNextRangeMaxValue.setValue(value);
        if (aNextRangeMaxValue.isModified()) {
            setModified(true);
        }
    }
    
    public void setNextRangeMaxValue(Object value) {
        aNextRangeMaxValue.setValue(value);
        if (aNextRangeMaxValue.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyNextRangeMaxValue() {
        if (!aNextRangeMaxValue.isNull()) {
            aNextRangeMaxValue.setNull(true);
            setModified(true);
        }
    }
    
    public DomBigInteger getNextRangeMaxValue() {
        return aNextRangeMaxValue;
    }
    
    public DomBigInteger oldNextRangeMaxValue() {
        return oNextRangeMaxValue;
    }
    
    public Long valueOfNextRangeMaxValue() {
        return aNextRangeMaxValue.getValue();
    }
    
    public boolean isNextRangeMaxValueModified() {
        return aNextRangeMaxValue.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo RANGE_SIZE">
    
    public EntSequences rangeSize(Integer value) {
        setRangeSize(value);
        return this;
    }
    
    public void setRangeSize(DomInteger value) {
        if (value == null || value.isNull()) {
            nullifyRangeSize();
        } else {
            aRangeSize.setValue(value.getValue());
            if (aRangeSize.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setRangeSize(String value) {
        if (value == null) {
            nullifyRangeSize();
        } else {
            aRangeSize.setValue(value);
            if (aRangeSize.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setRangeSize(Integer value) {
        aRangeSize.setValue(value);
        if (aRangeSize.isModified()) {
            setModified(true);
        }
    }
    
    public void setRangeSize(Object value) {
        aRangeSize.setValue(value);
        if (aRangeSize.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyRangeSize() {
        if (!aRangeSize.isNull()) {
            aRangeSize.setNull(true);
            setModified(true);
        }
    }
    
    public DomInteger getRangeSize() {
        return aRangeSize;
    }
    
    public DomInteger oldRangeSize() {
        return oRangeSize;
    }
    
    public Integer valueOfRangeSize() {
        return aRangeSize.getValue();
    }
    
    public boolean isRangeSizeModified() {
        return aRangeSize.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ATTRIBUTES">
    
    public EntSequences attributes(String value) {
        setAttributes(value);
        return this;
    }
    
    public void setAttributes(DomTextLong value) {
        if (value == null || value.isNull()) {
            nullifyAttributes();
        } else {
            aAttributes.setValue(value.getValue());
            if (aAttributes.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setAttributes(String value) {
        if (value == null) {
            nullifyAttributes();
        } else {
            aAttributes.setValue(value);
            if (aAttributes.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setAttributes(Object value) {
        aAttributes.setValue(value);
        if (aAttributes.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyAttributes() {
        if (!aAttributes.isNull()) {
            aAttributes.setNull(true);
            setModified(true);
        }
    }
    
    public DomTextLong getAttributes() {
        return aAttributes;
    }
    
    public DomTextLong oldAttributes() {
        return oAttributes;
    }
    
    public String valueOfAttributes() {
        return aAttributes.getValue();
    }
    
    public boolean isAttributesModified() {
        return aAttributes.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo RANDOM">
    
    public EntSequences random(String value) {
        setRandom(value);
        return this;
    }
    
    public void setRandom(DomFlag value) {
        if (value == null || value.isNull()) {
            nullifyRandom();
        } else {
            aRandom.setValue(value.getValue());
            if (aRandom.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setRandom(String value) {
        if (value == null) {
            nullifyRandom();
        } else {
            aRandom.setValue(value);
            if (aRandom.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setRandom(Object value) {
        aRandom.setValue(value);
        if (aRandom.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyRandom() {
        if (!aRandom.isNull()) {
            aRandom.setNull(true);
            setModified(true);
        }
    }
    
    public DomFlag getRandom() {
        return aRandom;
    }
    
    public DomFlag oldRandom() {
        return oRandom;
    }
    
    public String valueOfRandom() {
        return aRandom.getValue();
    }
    
    public boolean isRandomModified() {
        return aRandom.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    @Override
    protected void processDeleteCascade() throws AdsException {
        // Delete cascade SEQUENCE.SEQUENCE_NUMBERS.FK_SEQNUM_SEQUENCE
        {
            EntSequenceNumbers sequenceNumbers = new EntSequenceNumbers(ctx);
            sequenceNumbers.del("select id from SEQUENCE_NUMBERS where SEQUENCE_ID = " + valueOfId());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            if (msg.indexOf("FK_LOP_NOSSO_NUMERO_SEQUENCIA") >= 0) {
                e = new AdsException("FINANC.LOPS.FK_LOP_NOSSO_NUMERO_SEQUENCIA.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem LOPs fazendo referencia para este registro! (FK_LOP_NOSSO_NUMERO_SEQUENCIA)");
                return e;
            } else if (msg.indexOf("FK_CONCON_SEQUENCIADOR") >= 0) {
                e = new AdsException("CONTAB.CONTA_CONTABIL.FK_CONCON_SEQUENCIADOR.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Contas contábeis fazendo referencia para este registro! (FK_CONCON_SEQUENCIADOR)");
                return e;
            } else if (msg.indexOf("FK_PRODUTO_SEQUEN_SEQUENCIADOR_UNIDADE") >= 0) {
                e = new AdsException("PROD.PRODUTOS.FK_PRODUTO_SEQUEN_SEQUENCIADOR_UNIDADE.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Produtos fazendo referencia para este registro! (FK_PRODUTO_SEQUEN_SEQUENCIADOR_UNIDADE)");
                return e;
            } else if (msg.indexOf("FK_PRODUTO_SEQUEN_SEQUENCIADOR_UNIDADE_2") >= 0) {
                e = new AdsException("PROD.PRODUTOS.FK_PRODUTO_SEQUEN_SEQUENCIADOR_UNIDADE_2.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Produtos fazendo referencia para este registro! (FK_PRODUTO_SEQUEN_SEQUENCIADOR_UNIDADE_2)");
                return e;
            } else {
                e = new AdsException("SEQUENCE.SEQUENCES.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        } else {
            if (msg.indexOf("PK_SEQUEN") >= 0) {
                e = new AdsException("SEQUENCE.SEQUENCES.PK_SEQUEN", 
                        Severity.ERROR,
                        "ID duplicado! (PK_SEQUEN)");
                return e;
            } else if (msg.indexOf("UK_SEQUEN_SEQUENCE") >= 0) {
                e = new AdsException("SEQUENCE.SEQUENCES.UK_SEQUEN_SEQUENCE", 
                        Severity.ERROR,
                        "Registro duplicado! Já existe uma sequence cadastrada com este nome! Sequence ${SEQUENCE} (UK_SEQUEN_SEQUENCE)");
                return e;
            } else {
                e = new AdsException("SEQUENCE.SEQUENCES.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aSequence);
            allAttributes.add(aNextValue);
            allAttributes.add(aCache);
            allAttributes.add(aDescription);
            allAttributes.add(aMaxValue);
            allAttributes.add(aNextRangeMinValue);
            allAttributes.add(aNextRangeMaxValue);
            allAttributes.add(aRangeSize);
            allAttributes.add(aAttributes);
            allAttributes.add(aRandom);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return getSequence().toString();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    
    public void findBySequence(String sequence) throws AdsException {
        findBy(new String[] {"SEQUENCE"},
                new Object[] {sequence});
    }
    /**
     * Retorna os registros de SEQUENCE_NUMBERS que referenciam este registro através do atributo SEQUENCE_ID
     */
    public EntSequenceNumbers findAllSequenceNumbersSequence() throws AdsException {
        return findAllSequenceNumbersSequence("order by ID");
    }
    
    /**
     * Retorna os registros de SEQUENCE_NUMBERS que referenciam este registro através do atributo SEQUENCE_ID
     */
    public EntSequenceNumbers findAllSequenceNumbersSequence(String sqlAppend) throws AdsException {
        EntSequenceNumbers out = new EntSequenceNumbers(ctx);
        out.find("select ID from SEQUENCE_NUMBERS where SEQUENCE_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oNextRangeMinValue.setValue(aNextRangeMinValue);
        oNextRangeMaxValue.setValue(aNextRangeMaxValue);
        oId.setValue(aId);
        oAttributes.setValue(aAttributes);
        oRangeSize.setValue(aRangeSize);
        oSequence.setValue(aSequence);
        oDescription.setValue(aDescription);
        oCache.setValue(aCache);
        oMaxValue.setValue(aMaxValue);
        oNextValue.setValue(aNextValue);
        oRandom.setValue(aRandom);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntSequences.class);
            rule.setName("PK_SEQUEN");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntSequences.class);
            rule.setName("UK_SEQUEN_SEQUENCE");
            rule.addAttribute(new DomUpper("SEQUENCE",""));
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
        if (getCache().isNull()) {
            setCache(getCache().getDefaultValue());
        }
        if (getNextValue().isNull()) {
            setNextValue(getNextValue().getDefaultValue());
        }
        if (getRandom().isNull()) {
            setRandom(getRandom().getDefaultValue());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
    
    /**
     * Gerar números.
     * <p>
     * Permite criar números para as sequencias de números aleatórios.
     */
    public void gerarNumeros(long valorInicial, long valorFinal) throws AdsException {
        // <user-code id="11636300" parentId="11636297" hashcode="-4c08caef" length="220">
        EntSequenceNumbers numero = new EntSequenceNumbers(ctx);
        for (long n = valorInicial; n <= valorFinal; n++) {
            numero.nullify();
            numero.setSequenceId(valueOfId());
            numero.setNumber(n);
            numero.ins();
        }
        // </user-code>
    }
    
    /**
     * Retornar sequencia.
     * <p>
     * Retonar o próxima sequencia valida para utilização.
     */
    public long retornarSequencia() throws AdsException {
        // <user-code id="843007" parentId="843005" hashcode="47383a9d" length="1759">
        if ("S".equals(valueOfRandom())) {
            if (!ctx.isInTransaction()) {
                throw new AdsException(ENTITY_NAME + ".SEM_TRANSACAO", 
                        AdsException.CRITICAL, 
                        "A busca de números foi realizada FORA de uma transação no banco de dados!"
                                + " Chame o suporte do sistema!");
            }
            Long idnumero = br.com.telescope.util.JdbcUtil.getFirst(Long.class, "select id"
                    + " from SEQUENCE_NUMBERS"
                    + " where sequence_id = ?"
                    + " and consumed = 'N'"
                    + " order by ordering", valueOfId());
            if (idnumero == null) {
                throw new AdsException(ENTITY_NAME + ".SEM_NUMEROS_DISPONIVEIS", 
                        AdsException.ERROR, 
                        "Não existem mais números disponíveis na sequencia " + valueOfSequence() + "!");
            }
            EntSequenceNumbers nuseq = new EntSequenceNumbers(ctx);
            nuseq.findById(idnumero);
            nuseq.setConsumed("S");
            nuseq.upd();
            return nuseq.valueOfNumber();
            
        } else {
            if (getMaxValue().isNotNull() && valueOfMaxValue()>0)  {
                if (valueOfNextValue() > valueOfMaxValue()) {
                    if (getNextRangeMinValue().isNull() || valueOfNextRangeMinValue()==0) {
                        throw new AdsException(ENTITY_NAME + ".NEXT_SEQUENCE",
                            AdsException.ERROR, 
                            "Não existe um novo valor para sequencia!");
                    } else {
                        setNextValue(valueOfNextRangeMinValue());
                        setMaxValue(valueOfNextRangeMaxValue());
                        nullifyNextRangeMaxValue();
                        nullifyNextRangeMinValue();
                    }
                }
            }
            long i = valueOfNextValue();
            setNextValue(i + 1);
            upd();
            return i;
        }
        // </user-code>
    }
    
    /**
     * Search max value.
     * <p>
     * Procura na base de dados o maior valor utilizado para este sequencia.
     * <P>
     * Utiliza a informação em "Attributes" para pesquisar as tabelas da 
     * base.
     * <P>
     */
    public long searchMaxValue() throws AdsException {
        // <user-code id="834292" parentId="834290" hashcode="-6dadf243" length="1244">
        // import java.util.List;
        // import java.util.Arrays;
        // import br.com.telescope.t2.ApplicationInfo;
        // import br.com.telescope.t2.EntityBean;
        // import br.com.telescope.util.JdbcUtil;
        
        long max = 0;
        List<String> list;
        String attrs = valueOfAttributes().trim();
        if ("*".equals(attrs)) {
            list = new ArrayList<String>();
            ApplicationInfo appinfo = ApplicationInfo.getInstance();
            List<EntityBean> ents = appinfo.getEntities();
            for(EntityBean ent : ents) {
                try {
                    Entity e = (Entity) Class.forName(ent.getClassName()).newInstance();
                    if (e.idSequenceName().equals(valueOfSequence())) {
                        list.add(ent.getGlobalName() + ".ID");
                    }
                } catch (Exception ignore) {
                    
                }
            }
        } else {
            list = Arrays.asList(attrs.split("\n"));
        }
        for (String attr : list) {
            String[] parts = attr.split("\\.");
            String column = parts[parts.length-1];
            String table = parts[parts.length-2];
            Long tmax = JdbcUtil.getFirst(Long.class, 
                    "select max(" + column + ")"
                    + " from " + table);
            //ctx.p("Max for " + attr + " = " + tmax + "<br>");
            if (tmax != null && tmax > max) max = tmax;
        }
        return max;
        // </user-code>
    }
}
